// 线段树方案 - 使用线段树维护评分变化
// noipNOI 听听如何讲解

#include <bits/stdc++.h>
using namespace std;

// 常量定义
const long long MAXN = 5e5 + 10; // 最大可能的评分值

// 全局变量
long long n, q;             // n表示竞赛场数，q表示查询数量
long long L[MAXN], R[MAXN]; // L[i]和R[i]分别表示第i场竞赛的评分区间左右边界

// 查询节点结构体，用于离线处理查询
struct QueryNode {
  long long score, idx; // score表示评分值，idx表示原始位置
  // 重载小于运算符，按评分值排序
  bool operator<(const QueryNode &other) const { return score < other.score; }
} queries[600010];

// 线段树结构体
struct SegmentTree {
  static const long long MAX_NODES = 3000010;

  // 线段树相关数组
  long long lazy[MAX_NODES];    // 懒惰标记数组
  long long min_val[MAX_NODES]; // 节点区间的最小值
  long long max_val[MAX_NODES]; // 节点区间的最大值
  long long pos[MAX_NODES];     // 存储位置信息
  long long ans[600010];        // 存储最终答案

  long long query_count; // 查询数量

  // 构造函数
  SegmentTree() {
    memset(lazy, 0, sizeof(lazy));
    memset(min_val, 0, sizeof(min_val));
    memset(max_val, 0, sizeof(max_val));
    memset(pos, 0, sizeof(pos));
    memset(ans, 0, sizeof(ans));
    query_count = 0;
  }

  /**
   * 构建线段树
   * @param node 当前线段树节点编号
   * @param l 当前节点表示区间的左边界
   * @param r 当前节点表示区间的右边界
   */
  void build(long long node, long long l, long long r, QueryNode queries[]) {
    // 如果是叶子节点
    if (l == r) {
      // 初始化叶子节点的最小值和最大值为对应查询的评分值
      min_val[node] = max_val[node] = queries[l].score;
      // 记录该节点对应查询的原始位置
      pos[node] = queries[l].idx;
      return;
    }

    // 计算中点
    long long mid = (l + r) >> 1;

    // 递归构建左右子树
    build(node * 2, l, mid, queries);
    build(node * 2 + 1, mid + 1, r, queries);

    // 更新当前节点的最小值和最大值
    min_val[node] = min(min_val[node * 2], min_val[node * 2 + 1]);
    max_val[node] = max(max_val[node * 2], max_val[node * 2 + 1]);
  }

  /**
   * 给线段树节点增加值（用于懒惰标记）
   * @param node 当前线段树节点编号
   * @param l 当前节点表示区间的左边界
   * @param r 当前节点表示区间的右边界
   * @param val 要增加的值
   */
  void add(long long node, long long l, long long r, long long val) {
    // 更新节点维护的最小值、最大值和懒惰标记
    min_val[node] += val;
    max_val[node] += val;
    lazy[node] += val;
  }

  /**
   * 下传懒惰标记
   * @param node 当前线段树节点编号
   * @param l 当前节点表示区间的左边界
   * @param r 当前节点表示区间的右边界
   * @param mid 中点位置
   */
  void push_down(long long node, long long l, long long r, long long mid) {
    // 将当前节点的懒惰标记传递给左右子节点
    add(node * 2, l, mid, lazy[node]);
    add(node * 2 + 1, mid + 1, r, lazy[node]);

    // 清空当前节点的懒惰标记
    lazy[node] = 0;
  }

  /**
   * 修改线段树区间（核心操作）
   * @param node 当前线段树节点编号
   * @param l 当前节点表示区间的左边界
   * @param r 当前节点表示区间的右边界
   * @param x 区间左边界
   * @param y 区间右边界
   */
  void modify(long long node, long long l, long long r, long long x,
              long long y) {
    // 如果是叶子节点
    if (l == r) {
      // 如果当前节点的值在更新区间[x,y]内，则增加1
      if (min_val[node] >= x && max_val[node] <= y) {
        min_val[node]++;
        max_val[node]++;
      }
      return;
    }

    // 如果当前节点表示的区间完全包含在更新区间[x,y]内
    if (x <= min_val[node] && max_val[node] <= y) {
      // 直接更新当前节点的值和懒惰标记
      min_val[node]++;
      max_val[node]++;
      lazy[node]++;
      return;
    }

    // 计算中点
    long long mid = (l + r) >> 1;

    // 下传懒惰标记
    push_down(node, l, r, mid);

    // 递归更新左右子树（线段树二分）
    // 如果左子树的最大值>=x，则需要更新左子树
    if (x <= max_val[node * 2])
      modify(node * 2, l, mid, x, y);

    // 如果右子树的最小值<=y，则需要更新右子树
    if (y >= min_val[node * 2 + 1])
      modify(node * 2 + 1, mid + 1, r, x, y);

    // 更新当前节点的最小值和最大值
    min_val[node] = min(min_val[node * 2], min_val[node * 2 + 1]);
    max_val[node] = max(max_val[node * 2], max_val[node * 2 + 1]);
  }

  /**
   * 重构线段树，获取最终答案
   * @param node 当前线段树节点编号
   * @param l 当前节点表示区间的左边界
   * @param r 当前节点表示区间的右边界
   */
  void rebuild(long long node, long long l, long long r) {
    // 如果是叶子节点
    if (l == r) {
      // 将当前节点的最大值（即最终评分）存入对应位置的答案数组
      ans[pos[node]] = max_val[node];
      return;
    }

    // 计算中点
    long long mid = (l + r) >> 1;

    // 下传懒惰标记
    push_down(node, l, r, mid);

    // 递归处理左右子树
    rebuild(node * 2, l, mid);
    rebuild(node * 2 + 1, mid + 1, r);
  }

  /**
   * 输出所有查询的答案
   */
  void output_answers() {
    for (long long i = 1; i <= query_count; i++) {
      cout << ans[i] << '\n';
    }
  }
};

int main() {
  // 提高IO效率
  ios::sync_with_stdio(false);
  cin.tie(nullptr);
  cout.tie(nullptr);

  // 读入竞赛场数
  cin >> n;

  // 读入每场竞赛的评分区间
  for (long long i = 1; i <= n; i++) {
    cin >> L[i] >> R[i];
  }

  // 读入查询数量
  cin >> q;

  // 读入所有查询的初始评分值
  for (long long i = 1; i <= q; i++) {
    cin >> queries[i].score;
    queries[i].idx = i; // 记录原始位置
  }

  // 按评分值对查询排序（离线处理）
  sort(queries + 1, queries + 1 + q);

  // 创建线段树实例
  SegmentTree seg_tree;
  seg_tree.query_count = q;

  // 构建线段树
  seg_tree.build(1, 1, q, queries);

  // 对每场竞赛进行处理
  for (long long i = 1; i <= n; i++) {
    // 在线段树上更新对应的区间
    seg_tree.modify(1, 1, q, L[i], R[i]);
  }

  // 重构线段树获取最终答案
  seg_tree.rebuild(1, 1, q);

  // 输出所有查询的答案
  seg_tree.output_answers();

  return 0;
}